Java : les collections

List, Set et Map

La base : les tableaux

Java permet, comme beaucoup d'autres langages, de stocker une série d'élements du même type dans une variable tableau (array).

float[] mesNotes = {10, 15.5, 8}; String[] lesBeatles = {"Lennon", "McCartney", "Harrison", "Starr"}; Hero[] combatants = {new Hero("Gandalf", 20), new Hero("Balrog", 25) }

Une fois crées, les élements peuvent être lus ou modifiés à partir de leur index, le premier élément commençant à 0 et le dernier à la taille du tableau, moins 1 :

float uneNote = mesNotes[1]; String dernierBeatles = lesBeatles[lesBeatles.length-1]; Hero personnagePrincipal = combatants[0];

L'inconvénient de ces tableaux, c'est que leur taille est fixe.

Pour ajouter un élément dans un tableau, il faut créer un nouveau tableau avec la bonne taille, replacer les valeurs d'origine, et enfin ajouter la nouvelle valeur, ce qui est très fastidieux.

Les collections Java

Pour simplifier ces problématiques, et apporter de nouvelles fonctionalités très interressantes, Java fournit des interfaces et des classes pour nous aider à manipuler nos données pendant l'exécution de notre programme.

Elles se trouvent dans le package java.util

Il existe 3 interfaces principales : List, Set et Map.

Java fournit aussi plusieurs implémentations (classes) pour chacunes de ces interfaces.

Les List : Une liste indexée d'objets

Principe : Une série d'éléments rangés, indexés, de taille variable.

L'interface List<E>

Toutes les méthodes de List : http://developer.android.com/reference/java/util/List.html

Le <E> (ou n'importe qu'elle autre lettre) représente le nom de la classe que doit contenir la collection.

Les méthodes principales :

//ajout boolean add(E object); //ajoute un élément à la fin void add(int location, E object); //ajoute un élémet a l'index donné //lecture E get(int location); //renvoie l'élément à l'index donné boolean contains(Object object); //vérifie si l'élément est dans la liste int indexOf(Object object); //renvoie l'index de l'élément dans la liste //supression void clear(); //vide la liste E remove(int location); //supprime l'élement à l'index donné //info int size(); //renvoie le nombre d'élement dans la liste

L'implémentation la plus classique d'une List : ArrayList

La classe ArrayList implémente l'interface List, et se base en réalité sur tableau "classique".

Cette implémentation est idéale pour la plupart des cas, et remplacera la plupart du temps l'utilisation d'un tableau classique.

Il existe d'autres implémentations de l'interface List comme LinkedList et Vector, chacune avec des avantages et des invénients.

Il est tout à fait possible de créer une implémentation de l'intertace pour répondre à des besoins précis.

Dans tous les cas et pour pouvoir profiter de ces possibilités, il faut que les méthodes qui manipulent des listes dépendent de l'interface et non d'une des implémentation concrète.

Exemple :

Personnage perso1 = new Personnage(); perso1.nom = "Gandalf"; perso1.vie = 20; Personnage perso2 = new Personnage(); perso2.nom = "Balrog"; perso2.vie = 25; List<Personnage> maListe = new ArrayList<Personnage>(); maListe.add(perso1); maListe.add(perso2); System.out.println( maListe.size() + " éléments" ); for (int i=0; i < maListe.size(); i++) { System.out.println( maListe.get(i).nom + " : " + maListe.get(i).vie ); } maListe.clear(); System.out.println( maListe.size() + " éléments" );

2 éléments Gandalf : 20 Balrog : 25 0 éléments

Un autre exemple :

List<Integer> liste = new ArrayList<Integer>(); liste.add(2000); liste.add(2004); liste.add(2008); liste.add(2012); liste.add(2016); System.out.println(liste.size() + " éléments"); System.out.println(liste.get(0)); System.out.println(liste.get( liste.size()-1 )); if (liste.contains(2012)) { System.out.print( "2012 est dans la liste" ); System.out.println( " en position " + liste.indexOf(2012) ); }

5 éléments 2000 2016 2012 est dans la liste en position 3

Les Map : Association d'objets

L'interface Map<K, V>

Toutes les méthodes de Map : http://developer.android.com/reference/java/util/Map.html

Le <K, V> (ou n'importe qu'elle autre lettre) représentent les nom des la classe que doit contenir la collection : la premiere réprésente la clé, et l'autre la valeur.

Une Map permet d'associer une valeur à une clé. La clé étant une classe, et la valeur une autre (ou la même). On s'en sert pour stocker des dictionnaires, des classements, pour indexer des valeurs avec autre chose que des chiffres.

Les méthodes principales :

//ajout V put(K key, V value) //ajoute une association clé/valeur //lecture boolean containsKey(Object key) //vérifie si la clé existe, avec n'importe quelle valeur boolean containsValue(Object value) //vérifie si la valeur existe, deriere n'importe quelle clé V get(Object key) //renvoie la valeur dériere la clé passée. //suppresion void clear() //vide toutes les associations //info int size() //retourne le nombre d'associations

L'implémentation la plus classique d'un Map : HashMap

Exemple :

Map<String, String> monnaies = new HashMap<String, String>(); monnaies.put("france", "euro"); monnaies.put("usa", "dollar"); monnaies.put("japon", "yen"); System.out.println(monnaies.size() + " monnaies")); System.out.println(monnaies.get("france")); System.out.println(monnaies.get("japon"));

3 monnaies euro yen

Autre exemple :

Map<String, Integer> connections = new HashMap<String, Integer>(); connections.put("John", 0); connections.put("Jack", 0); connections.put("Robert", 0); connections.put("Robert", connections.get("Robert") + 2); System.out.println(connections.size() + " connections")); System.out.println(connections.get("John") + " connections"); System.out.println(connections.get("Robert") + " connections");

3 connections 0 connections 2 connections

Les Set : un ensemble non indexé d'éléments

L'interface Set<E>

Toutes les méthodes de Set : http://developer.android.com/reference/java/util/Set.html

Le principe d'un ensemble est de rassembler des éléments, mais sans ordre défini.

Les méthodes principales :

//ajout boolean add(E object); //ajoute un élément //lecture boolean contains(Object object); //vérifie si l'élément est dans l'ensemble //supression void clear(); //vide //info int size(); //renvoie le nombre d'élement dans l'ensemble

L'implémentation la plus classique d'une set : HashSet

Exemple

Set<String> bureauDeVote = new HashSet<String>(); bureauDeVote.add("Nicolas"); bureauDeVote.add("Francois"); bureauDeVote.add("Jean-François"); if (bureauDeVote.contains("Jean-François")) { System.out.println("Jean-François à déjà voté !"); } else { bureauDeVote.add("Jean-François"); } System.out.println(bureauDeVote.size() + " votes"));

Jean-François à déjà voté ! 3 votes